package com.ruoyi.api.common;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.types.ObjectId;
import org.springframework.data.domain.*;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import java.util.List;
import java.lang.reflect.Field;
// 服务接口
public interface BaseService<T> {

    default Page<T> selectList(Class<T> tClass, T filterCriteria, int pageNum, int pageSize,MongoTemplate mongoTemplate) throws IllegalAccessException {
        // 数据获取和分页逻辑
        Query query = new Query();

        // 使用反射来获取filterCriteria的属性并构建查询条件
        Field[] fields = filterCriteria.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(filterCriteria);

            if (value != null) {

                if(field.getName().equals("email") || field.getName().equals("name") || field.getName().equals("title") || field.getName().equals("categories")){
                    query.addCriteria(Criteria.where(field.getName()).regex(value.toString(),"i"));
                }else if(field.getName().equals("guidIdList")){
                    // 对于 guidIdList 字段，如果 value 是一个数组，使用 $in 运算符
                    if (value instanceof List) {
                        query.addCriteria(Criteria.where("_id").in((List<?>) value));
                    } else {
                        // 如果 value 不是 List 类型，处理异常或记录日志
                        throw new IllegalArgumentException("Expected value for guidIdList to be a List");
                    }
                }else if(field.getName().equals("categories")){
                    // 对于 guidIdList 字段，如果 value 是一个数组，使用 $in 运算符
                    if (value instanceof List) {
                        query.addCriteria(Criteria.where("categories").in((List<?>) value));
                    } else {
                        // 如果 value 不是 List 类型，处理异常或记录日志
                        throw new IllegalArgumentException("Expected value for guidIdList to be a List");
                    }
                }else if(field.getName().equals("types")){
                    // 对于 guidIdList 字段，如果 value 是一个数组，使用 $in 运算符
                    if (value instanceof List) {
                        query.addCriteria(Criteria.where("type").in((List<?>) value));
                    } else {
                        // 如果 value 不是 List 类型，处理异常或记录日志
                        throw new IllegalArgumentException("Expected value for guidIdList to be a List");
                    }
                }else if (field.getName().equals("noMine")) {
                    query.addCriteria(Criteria.where("attribute").ne(value));
                }
                else {
                    query.addCriteria(Criteria.where(field.getName()).is(value));
                }
            }

        }
        // 获取总记录数
        long total = mongoTemplate.count(query,  tClass);
        // 设置分页
        Pageable pageable = PageRequest.of(pageNum, pageSize);

        query.with(Sort.by(Sort.Order.desc("_id")));

        query.with(pageable);

        // 执行查询
        List<T> users = mongoTemplate.find(query,  tClass);

        Page<T> page = new PageImpl<>(users, pageable, total);

        return page;

    }

    default T selectOne(Class<T> tClass, T filterCriteria,MongoTemplate mongoTemplate)  {
        // 数据获取和分页逻辑
        Query query = new Query();

        // 使用反射来获取filterCriteria的属性并构建查询条件
        Field[] fields = filterCriteria.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = null;
            try {
                value = field.get(filterCriteria);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
            if (value != null) {
                query.addCriteria(Criteria.where(field.getName()).is(value));
            }
        }

        // 执行查询
        T users = mongoTemplate.findOne(query,  tClass);



        return users;

    }

    default <T> List<T> selectAll(Class<T> tClass, T filterCriteria, MongoTemplate mongoTemplate) {
        // 数据获取和分页逻辑
        Query query = new Query();

        // 使用反射来获取filterCriteria的属性并构建查询条件
        Field[] fields = filterCriteria.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = null;
            try {
                value = field.get(filterCriteria);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
            if (value != null) {
                query.addCriteria(Criteria.where(field.getName()).is(value));
            }
        }

        // 执行查询，获取所有匹配的记录
        List<T> results = mongoTemplate.find(query, tClass);

        return results;
    }

    default DeleteResult deleteByIds(Class<T> tClass, String[] ids, MongoTemplate mongoTemplate){
        ObjectId[] objectIds = new ObjectId[ids.length];
        for (int i = 0; i < ids.length; i++) {
            objectIds[i] = new ObjectId(ids[i]);
        }
        // 构建查询条件，根据_id批量匹配
        Query query = new Query(Criteria.where("_id").in(objectIds));
        DeleteResult deleteResult = mongoTemplate.remove(query, tClass);
        // 执行删除操作
        return deleteResult;
    }

    default DeleteResult deleteById(Class<T> tClass, String id, MongoTemplate mongoTemplate){
        // 构建查询条件，根据_id批量匹配
        Query query = new Query(Criteria.where("_id").in(new ObjectId(id)));
        DeleteResult deleteResult = mongoTemplate.remove(query, tClass);
        // 执行删除操作
        return deleteResult;
    }

    default T getInfoById(Class<T> tClass, String ids, MongoTemplate mongoTemplate){
        // 构建查询条件，根据_id批量匹配
        if(null!=ids){
            Query query = new Query(Criteria.where("_id").is(new ObjectId(ids)));
            T s = mongoTemplate.findOne(query, tClass);
            return s;
        }
        // 执行删除操作
        return null;
    }

    default boolean update(Class<T> tClass, T user, MongoTemplate mongoTemplate){
        // 获取实体类中的 id 字段值

        Object id = getId(user);

        if (id == null) {

            mongoTemplate.save(user);
            return true;
        }

        // 创建查询条件，匹配 ID
        Query query = new Query(Criteria.where("_id").is(id));

        // 创建更新对象，将 user 的字段值复制到更新对象中
        Update update = new Update();
        populateUpdateFields(update, user);

        // 执行更新操作
        UpdateResult result = mongoTemplate.updateFirst(query, update, tClass);

        // 返回更新结果信息
        return result.getMatchedCount() > 0 ? true : false;

    }
    /**
     * 获取实体的 ID
     *
     * @param user 实体对象
     * @return 实体的 ID
     */
    default <T> Object getId(T user) {
        // 需要根据实体的实际 ID 字段名称调整此逻辑
        // 假设 ID 字段名称是 "id"
        try {
            Field idField = user.getClass().getDeclaredField("id");
            idField.setAccessible(true);
            return idField.get(user);
        } catch (NoSuchFieldException | IllegalAccessException e) {
//            throw new RuntimeException("Failed to get ID from user", e);
            return null;
        }
    }
    /**
     * 将实体的字段值添加到更新对象中
     *
     * @param update 更新对象
     * @param user 实体对象
     */
    default <T> void populateUpdateFields(Update update, T user) {

        Field[] fields = user.getClass().getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object value = field.get(user);
                if (value != null && !"id".equals(field.getName())) { // 排除 ID 字段
                    update.set(field.getName(), value);
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException("Failed to access field", e);
            }
        }
    }
}
